package persistent.impl;

import java.io.Serializable;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import basic.HibBaseDAO;
import basic.HibernateSessionFactory;
import model.TDimension;
import model.TDimensionScore;
import model.TScaleTitleType;
import persistent.dao.IDimensionDAO;
import util.toolkit.LogUtil;

/**
 * 量表维度处理业务接口实现类
 * @author 徐震霖
 * @since 2019-02-21
 * @since 改动 2019/2/25 djf
 */
public class DimensionImpl implements IDimensionDAO {
	
	private HibBaseDAO dao = null;
	private static final Log log = LogFactory.getLog(HibBaseDAO.class);
	
	public DimensionImpl() {
		dao = new HibBaseDAO();
	}

	/**
	 * 添加一个量表维度信息
	 * @param dimension 量表维度对象
	 * @return 成功返回自带给您编号列id，失败返回一个小于0的数
	 * @author djf
	 */
	@Override
	public boolean addDimension(TDimension dimension) {
		
		//TODO 2019-03-06 08:53 徐震霖修改开始
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		
		try {
			tx = session.beginTransaction();
			Serializable key = session.save(dimension);
			int row = ((Integer) key).intValue();
			for(int i = 0; i < 3; i++){
				TScaleTitleType type = new TScaleTitleType();
				switch (i) {			
				case 0:				
					type.setDescribe("A卷");
					type.setDimensionid(row);
					type.setName("A卷");
					type.setTitleNumber(0);
					break;
				case 1:
					type.setDescribe("B卷");
					type.setDimensionid(row);
					type.setName("B卷");
					type.setTitleNumber(0);
					break;
				case 2:
					type.setDescribe("C卷");
					type.setDimensionid(row);
					type.setName("C卷");
					type.setTitleNumber(0);
					break;
				}
				session.save(type);
			}
			tx.commit();
			session.close(); // 关闭连接
			return true;
		} catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.DimensionImpl类的addDimension(TDimension dimension)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.DimensionImpl类的addDimension(TDimension dimension)方法调用错误：");
			e.printStackTrace();
		}
		//TODO 2019-03-06 08:53 徐震霖修改结束
		return false;
		
	}

	/**
	 * 删除一条量表维度信息（必须先删除了维度标准分和维度选项才可以删除维度）
	 * @param dimensionid 量表维度信息编号
	 * @return 成功返回true，失败返回false
	 * @author djf
	 */
	@Override
	public boolean deleteDimension(int dimensionid) {
		//TODO 2019-03-06 08:53 徐震霖修改开始
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;	
		try {
			tx = session.beginTransaction();
			//先获取选项信息
			String hql = "from TScaleTitleType where dimensionid = ?";
			Object[] para = { dimensionid };
			List<TScaleTitleType> titleTypes = dao.select(hql, para);		
			//获取要删除的维度对象
			TDimension dimension = (TDimension) dao.findById(TDimension.class, dimensionid);
			if (titleTypes != null && titleTypes.size() > 0) {
				//删除选项信息
				for (TScaleTitleType tScaleTitleType : titleTypes) {
					session.delete(tScaleTitleType);
				}
				//删除维度信息
				session.delete(dimension);
				tx.commit();
				session.close(); // 关闭连接
				return true;
			}
			else {
				if (tx != null) tx.rollback();
				session.close(); // 关闭连接
				return false;
			}
		} catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.DimensionImpl类的deleteDimension(int dimensionid)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.DimensionImpl类的deleteDimension(int dimensionid)方法调用错误：");
			e.printStackTrace();
		}
		return false;
		//TODO 2019-03-06 08:53 徐震霖修改结束
	}

	/**
	 * 修改一个量表维度信息
	 * @param dimension 量表维度信息对象
	 * @return 成功返回true，失败返回false
	 * @author djf
	 */
	@Override
	public boolean updateDimension(TDimension dimension) {
		TDimension dimension2=(TDimension)dao.findById(TDimension.class, dimension.getDimensionid());
		dimension2.setDimensionName(dimension.getDimensionName());
		dimension2.setDimensionDescribe(dimension.getDimensionDescribe());
		dimension2.setIsDefault(dimension.getIsDefault());
		return dao.update(dimension2);
	}

	/**
	 * 根据id获得一条量表维度信息
	 * @param dimensionid 量表维度信息编号
	 * @return 成功返回量表维度对象，失败返回null
	 * @author djf
	 */
	@Override
	public TDimension getTDimension(int dimensionid) {
		return (TDimension)dao.findById(TDimension.class, dimensionid);
	}

	/**
	 * 根据条件获取量表维度信息对象列表(不带分页)
	 * @param strWhere 查询条件
	 * @return 成功返回量表维度对象列表，失败返回null
	 * @author djf
	 */
	@Override
	public List<TDimension> getDimensions(String strWhere) {
		String hql="from TDimension "+strWhere;
		return dao.select(hql);
	}

	/**
	 * 根据条件获取量表维度信息对象列表(带分页)
	 * @param strwhere 插叙条件
	 * @param currentPage 当前页
	 * @param pageSize 每页数
	 * @return 成功返回量表维度对象列表，失败返回null
	 * @author djf
	 */
	@Override
	public List<TDimension> getDimensions(String strwhere, int currentPage,
			int pageSize) {
		String hql="from TDimension "+strwhere;
		return dao.selectByPage(hql, currentPage, pageSize);
	}

	
	/**
	 * 添加一个量表维度标准分信息（先添加量表维度，再添加标准分）
	 * @param score 量表维度标准分对象
	 * @return 成功返回一个量表维度标准分信息编号，失败返回一个小于0的数
	 * @author djf
	 */
	@Override
	public int addDimensionScore(TDimensionScore score) {
		return dao.insert(score);
	}

	/**
	 * 删除一条量表维度标准分信息
	 * @param dimensionScoreid 量表维度标准分编号
	 * @return 成功返回true，失败返回false
	 * @author djf
	 */
	@Override
	public boolean deleteDimensionScore(int dimensionScoreid) {
		return dao.delete(TDimensionScore.class, dimensionScoreid);
	}

	/**
	 * 修改一个量表维度标准分信息
	 * @param dScore 量表维度标准分对象
	 * @return 成功返回true，失败返回false
	 * @author djf
	 */
	@Override
	public boolean updateDimensionScore(TDimensionScore dScore) {
		TDimensionScore dscore2=(TDimensionScore)dao.findById(TDimensionScore.class, 
				dScore.getId());
		dscore2.setDimensionLev(dScore.getDimensionLev());
		dscore2.setStartScore(dScore.getStartScore());
		dscore2.setEndScore(dScore.getEndScore());
		dscore2.setResultDescription(dScore.getResultDescription());
		dscore2.setExpertAdvice(dScore.getExpertAdvice());
		return dao.update(dscore2);
	}

	/**
	 * 根据id获得一条量表维度标准分信息
	 * @param dimensionScoreid 量表维度标准分信息编号
	 * @return 成功返回量表维度标准分对象，失败返回null
	 * @author djf
	 */
	@Override
	public TDimensionScore getTDimensionScore(int dimensionScoreid) {
		return (TDimensionScore)dao.findById(TDimensionScore.class, dimensionScoreid);
	}

	/**
	 * 根据条件获取量表维度标准分信息对象列表
	 * @param strWhere 查询条件
	 * @return 成功返回量表维度标准分对象列表，失败返回null
	 * @author djf
	 */
	@Override
	public List<TDimensionScore> getDimensionScores(String strWhere) {
		String hql="from TDimensionScore "+strWhere;
		return dao.select(hql);
	}

	/**
	 * 根据条件获取维度标准分列表
	 * @param strWhere 查询条件
	 * @param currentPage 当前页
	 * @param pageSize 每页条数
	 * @return 成功返回量表维度标准分列表，失败返回null
	 * @author djf
	 */
	@Override
	public List<TDimensionScore> getDimensionScores(String strWhere,
			int currentPage, int pageSize) {
		String hql="from TDimensionScore "+strWhere;
		return dao.selectByPage(hql, currentPage, pageSize);
	}

}
